Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/misc/volume9/fplan/part03

Text File | 1989-11-26 | 23.6 KB | 744 lines

Newsgroups: comp.sources.misc
subject: v09i013: FPLAN 3/6
from: [e-mail] (Brandon S. Allbery - comp.sources.misc)
Reply-To: [e-mail] (Steve Tynor)

Posting-number: Volume 9, Issue 13
Submitted-by: [e-mail] (Steve Tynor)
Archive-name: fplan/part03

#This is part 3/6 of FPLAN
#!/bin/sh
# shar:    Shell Archiver  (v1.22)
#    Packed Mon Nov 20 19:28:37 EST 1989 by gaffa!tynor
#    from directory /files/home/users/tynor/src/fplan
#
#    Run the following text with /bin/sh to create:
#      add.c
#      compute.c
#
echo "x - extracting add.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > add.c &&
X/*
X * $Id: add.c,v 2.5 89/11/11 19:09:43 tynor Exp $
X *----------------------------------------------------------------------------
X *    FPLAN - Flight Planner
X *    Steve Tynor
X *    [e-mail]
X *
X *    This program is in the public domain. Permission to copy,
X * distribute, modify this program is hearby given as long as this header
X * remains. If you redistribute this program after modifying it, please
X * document your changes so that I do not take the blame (or credit) for
X * those changes.  If you fix bugs or add features, please send me a
X * patch so that I can keep the 'official' version up-to-date.
X *
X *    Bug reports are welcome and I'll make an attempt to fix those
X * that are reported.
X *
X *    USE AT YOUR OWN RISK! I assume no responsibility for any
X * errors in this program, its database or documentation. I will make an
X * effort to fix bugs, but if you crash and burn because, for example,
X * fuel estimates in this program were inaccurate, it's your own fault
X * for trusting somebody else's code! Remember, as PIC, it's _your_
X * responsibility to do complete preflight planning. Use this program as
X * a flight planning aid, but verify its results before using them.
X *----------------------------------------------------------------------------
X */
X
Xstatic char rcsid[] = "$Id: add.c,v 2.5 89/11/11 19:09:43 tynor Exp $";
X
X#include "wp_info.h"
X
Xextern char *malloc();
Xextern BOOLEAN lookup_desig ();
X
Xstatic BOOLEAN brief_mode = FALSE;
X
X#if 0
X/*----------------------------------------------------------------------------*/
Xstatic void find_intersection (desig1, radial1, desig2, radial2,
X                   latitude, longitude)
X     double  radial1, radial2;
X     char    *desig1, *desig2;
X     double  *latitude, *longitude;
X{
X   yyerror ("don't know how to find intersection yet");
X}
X#endif
X
X/*----------------------------------------------------------------------------*/
Xstatic void init_db (db)
XDATABASE_INFO *db;
X{
X   if (db) {
X      db->freq.valid = FALSE;
X      db->desig = (char*)0;
X      db->name = (char*)0;
X      db->city = (char*)0;
X      db->comment = (char*)0;
X      db->altitude.valid = FALSE;
X   }
X}
X
X/*----------------------------------------------------------------------------*/
Xstatic void new_waypoint ()
X{
X   extern yyerror();
X
X   if (num_waypoints >= MAX_NUM_WAYPOINTS)
X      yyerror ("too many waypoints");
X
X   if (num_waypoints > 0) {
X      waypoints[num_waypoints] = waypoints[num_waypoints-1];
X      waypoints[num_waypoints].refuel = FALSE;
X      waypoints[num_waypoints].extra_fuel_burn.valid = FALSE;
X   }
X
X   num_waypoints++;
X}
X
X/*----------------------------------------------------------------------------*/
Xvoid add_named_waypoint (kind, desig)
X     WAYPOINT_KIND kind;
X     char *desig;
X{
X   DATABASE_INFO *db;
X
X   if (lookup_desig (kind, desig, &db)) {
X      new_waypoint ();
X      waypoints[num_waypoints-1].wp_kind = kind;
X      waypoints[num_waypoints-1].db = db;
X   }
X}
X
X/*----------------------------------------------------------------------------*/
Xvoid add_inc_waypoint (dist_since_last_wp,
X               name_str, city_str, comment_str)
X     double dist_since_last_wp;
X     char   *name_str;
X     char   *city_str;
X     char   *comment_str;
X{
X   if (brief_mode)
X      return;
X
X   new_waypoint ();
X
X   waypoints[num_waypoints-1].db =
X      (DATABASE_INFO*) malloc (sizeof (DATABASE_INFO));
X   if (! waypoints[num_waypoints-1].db)
X      yyerror ("unable to allocate space for waypoint");
X
X   init_db (waypoints[num_waypoints-1].db);
X
X   waypoints[num_waypoints-1].db->mode = WP_INCREMENTAL;
X   waypoints[num_waypoints-1].wp_kind = WP_VIA;
X   waypoints[num_waypoints-1].db->name = name_str;
X   waypoints[num_waypoints-1].db->city = city_str;
X   waypoints[num_waypoints-1].db->comment = comment_str;
X
X   /*
X    * NOTE: we can't compute lat/long since we don't know the true course
X    * yet. So, just store the distance until print time.
X    */
X   waypoints[num_waypoints-1].db->u.dist_since_last_wp = dist_since_last_wp;
X}
X
X#if 0
X/*----------------------------------------------------------------------------*/
Xvoid add_int_waypoint (kind, desig1, radial1, desig2, radial2,
X               name_str, city_str, comment_str)
X     WAYPOINT_KIND kind;
X     double  radial1, radial2;
X     char    *desig1, *desig2, *name_str, *city_str, *comment_str;
X{
X   new_waypoint ();
X   waypoints[num_waypoints-1].db =
X      (DATABASE_INFO*) malloc (sizeof (DATABASE_INFO));
X   if (! waypoints[num_waypoints-1].db)
X      yyerror ("unable to allocate space for waypoint");
X
X   init_db (waypoints[num_waypoints-1].db);
X
X   find_intersection (desig1, radial1, desig2, radial2,
X              &waypoints[num_waypoints-1].db->latitude,
X              &waypoints[num_waypoints-1].db->longitude);
X   waypoints[num_waypoints-1].db->mode = WP_INTERSECTION;
X   waypoints[num_waypoints-1].wp_kind = kind;
X   waypoints[num_waypoints-1].db->name = name_str;
X   waypoints[num_waypoints-1].db->city = city_str;
X   waypoints[num_waypoints-1].db->comment = comment_str;
X}
X#endif
X
X/*----------------------------------------------------------------------------*/
Xvoid add_lat_waypoint (kind, latitude, longitude,
X               name_str, city_str, comment_str)
X     WAYPOINT_KIND kind;
X     double  latitude, longitude;
X     char    *name_str;
X     char    *city_str;
X     char    *comment_str;
X{
X   new_waypoint ();
X   waypoints[num_waypoints-1].db =
X      (DATABASE_INFO*) malloc (sizeof (DATABASE_INFO));
X   if (! waypoints[num_waypoints-1].db)
X      yyerror ("unable to allocate space for waypoint");
X
X   init_db (waypoints[num_waypoints-1].db);
X
X   waypoints[num_waypoints-1].db->mode = WP_LAT_LONG;
X   waypoints[num_waypoints-1].wp_kind = kind;
X   waypoints[num_waypoints-1].db->latitude = latitude;
X   waypoints[num_waypoints-1].db->longitude = longitude;
X   waypoints[num_waypoints-1].db->name = name_str;
X   waypoints[num_waypoints-1].db->city = city_str;
X   waypoints[num_waypoints-1].db->comment = comment_str;
X}
X
X/*----------------------------------------------------------------------------*/
Xvoid set_xfix (vor_num, vor_desig)
Xint vor_num;
Xchar *vor_desig;
X{
X   char buffer[80];
X   int i = MAX (0, num_waypoints-1);
X
X   if ((vor_num < 1) || (vor_num > MAX_NUM_VOR_FIXES)) {
X      sprintf (buffer, "Invalid NAV number. Must be between 1 and %d",
X           MAX_NUM_VOR_FIXES);
X      yyerror (buffer);
X   }
X   if (lookup_desig (WP_VIA, vor_desig, &waypoints[i].vor_fix[vor_num-1].db)) {
X      waypoints[i].vor_fix[vor_num-1].valid = TRUE;
X      max_nav = MAX (max_nav, vor_num-1);
X   }
X}
X
X/*----------------------------------------------------------------------------*/
Xvoid set_tas (tas)
X     double tas;
X{
X   int i = MAX (0, num_waypoints-1);
X
X   waypoints[i].tas.valid = TRUE;
X   waypoints[i].tas.value = tas;
X}
X
X/*----------------------------------------------------------------------------*/
Xvoid set_wind (heading, speed)
X     double heading, speed;
X{
X   int i = MAX (0, num_waypoints-1);
X
X   waypoints[i].wind_speed.valid = TRUE;
X   waypoints[i].wind_speed.value = speed;
X   waypoints[i].wind_direction.valid = TRUE;
X   waypoints[i].wind_direction.value = heading;
X}
X
X/*----------------------------------------------------------------------------*/
Xvoid set_fuel_amt (amt)
X     double amt;
X{
X   int i = MAX (0, num_waypoints-1);
X
X   waypoints[i].refuel         = TRUE;
X   waypoints[i].fuel_amt.valid = TRUE;
X   waypoints[i].fuel_amt.value = amt;
X}
X
X/*----------------------------------------------------------------------------*/
Xvoid set_extra_fuel_burn (amt)
X     double amt;
X{
X   int i = MAX (0, num_waypoints-1);
X
X   waypoints[i].extra_fuel_burn.valid = TRUE;
X   waypoints[i].extra_fuel_burn.value = amt;
X}
X
X/*----------------------------------------------------------------------------*/
Xvoid set_fuel_rate (rate)
X     double rate;
X{
X   int i = MAX (0, num_waypoints-1);
X
X   waypoints[i].fuel_rate.valid = TRUE;
X   waypoints[i].fuel_rate.value = rate;
X}
X
X/*----------------------------------------------------------------------------*/
Xvoid set_altitude (feet)
X     double feet;
X{
X   int i = MAX (0, num_waypoints-1);
X
X   waypoints[i].altitude.valid = TRUE;
X   waypoints[i].altitude.value = feet;
X}
X
X/*----------------------------------------------------------------------------*/
Xvoid set_brief (on_off)
X     BOOLEAN on_off;
X{
X   brief_mode = on_off;
X}
X
X
SHAR_EOF
chmod 0444 add.c || echo "restore of add.c fails"
echo "x - extracting compute.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > compute.c &&
X/*
X * $Id: compute.c,v 2.6 89/11/14 20:27:46 tynor Exp $
X *----------------------------------------------------------------------------
X *    FPLAN - Flight Planner
X *    Steve Tynor
X *    [e-mail]
X *
X *    This program is in the public domain. Permission to copy,
X * distribute, modify this program is hearby given as long as this header
X * remains. If you redistribute this program after modifying it, please
X * document your changes so that I do not take the blame (or credit) for
X * those changes.  If you fix bugs or add features, please send me a
X * patch so that I can keep the 'official' version up-to-date.
X *
X *    Bug reports are welcome and I'll make an attempt to fix those
X * that are reported.
X *
X *    USE AT YOUR OWN RISK! I assume no responsibility for any
X * errors in this program, its database or documentation. I will make an
X * effort to fix bugs, but if you crash and burn because, for example,
X * fuel estimates in this program were inaccurate, it's your own fault
X * for trusting somebody else's code! Remember, as PIC, it's _your_
X * responsibility to do complete preflight planning. Use this program as
X * a flight planning aid, but verify its results before using them.
X *----------------------------------------------------------------------------
X */
X
Xstatic char rcsid[] = "$Id: compute.c,v 2.6 89/11/14 20:27:46 tynor Exp $";
X
X#include "wp_info.h"
X#include <math.h>
X
X/*----------------------------------------------------------------------------*/
Xstatic void wind_correct (true_air_speed, mag_course,
X              wind_speed, wind_heading,
X              ground_speed, mag_heading)
X     double true_air_speed, mag_course,
X    wind_speed, wind_heading,
X    *ground_speed, *mag_heading;
X{
X   double hdiff, tx, ty, wca;
X
X   if (wind_heading <= 180.0)
X      wind_heading += 180.0;
X   else
X      wind_heading -= 180.0;
X   hdiff = DEG2RAD (mag_course - wind_heading);
X   tx = wind_speed * sin (hdiff);
X   ty = wind_speed * cos (hdiff);
X   wca = asin (tx / true_air_speed);
X   *ground_speed = cos (wca) * true_air_speed + ty;
X   *mag_heading = mag_course + RAD2DEG (wca);
X   if (*mag_heading >= 360.0)
X      *mag_heading -= 360.0;
X   else if (*mag_heading <= 0.0)
X      *mag_heading += 360.0;
X}
X
X/*----------------------------------------------------------------------------*/
Xvoid distance_and_heading (lat1, long1, lat2, long2, distance, heading)
X     double lat1, long1, lat2, long2;
X     double *distance, *heading;
X{
X   double tmp;
X
X   lat1  = DEG2RAD (lat1);
X   long1 = DEG2RAD (long1);
X   lat2  = DEG2RAD (lat2);
X   long2 = DEG2RAD (long2);
X
X   if ((lat1 == lat2) && (long1 == long2)) {
X      *distance = 0.0;
X      *heading  = 0.0;
X      return;
X   }
X
X   tmp = atan2 (2.0 * asin (sin ((long1 - long2) / 2.0)),
X        log (tan (PI / 4.0 + lat2 / 2.0)) -
X        log (tan (PI / 4.0 + lat1 / 2.0)) );
X   if (lat1 == lat2)
X      *distance = 60.0 *
X     fabs (RAD2DEG (2.0 * asin (sin ((long1 - long2) / 2.0)))) *
X        cos (lat1);
X   else
X      *distance = 60.0 * RAD2DEG (lat2 - lat1) / cos (fabs (tmp));
X
X   if (asin (sin (long1-long2)) >= 0.0)
X      *heading = RAD2DEG (fabs(tmp));
X   else
X      *heading = 360.0 - RAD2DEG (fabs(tmp));
X}
X
X/*----------------------------------------------------------------------------*/
Xstatic int next_non_incremental (start)
X     int start;
X{
X   int i = start;
X
X   for (i = start; i < num_waypoints; i++)
X      if (waypoints[i].db->mode != WP_INCREMENTAL)
X     return i;
X   return -1;
X}
X
X/*----------------------------------------------------------------------------*/
Xstatic void locate_incrementals ()
X{
X   int    j, prev, next;
X   double d, heading;
X
X   for (prev = 0; ((prev >= 0) && (prev < num_waypoints)); ) {
X      next = next_non_incremental (prev+1);
X      if (next >= 0) {
X     distance_and_heading (waypoints[prev].db->latitude,
X                   waypoints[prev].db->longitude,
X                   waypoints[next].db->latitude,
X                   waypoints[next].db->longitude,
X                   &d, &heading);
X     for (j = prev+1; j < next; j++) {
X        if (waypoints[j].db->u.dist_since_last_wp >= 0.0) {
X           waypoints[j].db->latitude =  waypoints[prev].db->latitude +
X          (waypoints[next].db->latitude - waypoints[prev].db->latitude)
X             * waypoints[j].db->u.dist_since_last_wp / d;
X           waypoints[j].db->longitude =  waypoints[prev].db->longitude +
X          (waypoints[next].db->longitude -
X           waypoints[prev].db->longitude) *
X              waypoints[j].db->u.dist_since_last_wp / d;
X        } else {
X           waypoints[j].db->latitude =  waypoints[next].db->latitude +
X          (waypoints[next].db->latitude - waypoints[prev].db->latitude)
X             * waypoints[j].db->u.dist_since_last_wp / d;
X           waypoints[j].db->longitude =  waypoints[next].db->longitude +
X          (waypoints[next].db->longitude -
X           waypoints[prev].db->longitude) *
X              waypoints[j].db->u.dist_since_last_wp / d;
X        }
X     }
X      }
X      prev = next;
X   }
X}
X
X/*----------------------------------------------------------------------------*/
X#define IS_NAVAID(mode) (((mode) == WP_VOR) || ((mode) == WP_NDB) || \
X             ((mode) == WP_DME) || ((mode) == WP_TAC) || \
X             ((mode) == WP_ILS) || ((mode) == WP_LOM) || \
X             ((mode) == WP_LMM))
X
X/*----------------------------------------------------------------------------
X * FUZZ is the number of degrees two points can be apart and still be considered
X * colocated - we let this be fuzzy, since it's often the case that onfield VORs
X * are reported with slightly different lat/long, but we still want to view them
X * as the same point...
X */
X#define FUZZ 0.01
X#define COLOCATED(db1,db2) \
X   ((fabs ((db1)->latitude - (db2)->latitude) <= FUZZ) && \
X    (fabs ((db1)->longitude - (db2)->longitude) <= FUZZ))
X
X/*----------------------------------------------------------------------------*/
Xstatic DATABASE_INFO *get_navaid (wp)
X     WAYPOINT_INFO wp;
X     /*
X      * If the waypoint is a navaid return its db pointer. If it's an airport
X      * and there's a navaid colocated on the field, return it's db pointer,
X      * else return NULL.
X      */
X{
X   DATABASE_INFO *db;
X   extern BOOLEAN lookup_desig ();
X
X   if (IS_NAVAID (wp.db->mode)) {
X      return (wp.db);
X   } else if ((wp.db->mode == WP_AIRPORT) &&
X          (lookup_desig (WP_VIA, wp.db->desig, &db)) &&
X          IS_NAVAID (db->mode) &&
X          COLOCATED (db, wp.db) ) {
X      return (db);
X   } else {
X      return ((DATABASE_INFO*) 0);
X   }
X}
X
X/*----------------------------------------------------------------------------*/
Xstatic track_nav1 ()
X     /*
X      * for each waypoint, determine what VOR to tune in on NAV1.
X      *
X      * This is tricky - some waypoints are navaids - so we want to track to
X      * (and sometimes from) them - others are just "distance-since-last-
X      * -waypoint" or "lat/long" waypoints, and we can't track to those.
X      * From and To Airports also sometimes have VORS on-field, so we need to
X      * recognize when that happens so that we can track to/from airport
X      * waypoints.
X      *
X      * The vor_fix[0] for each waypoint is for the leg _between_ that waypoint
X      * and the next one. If there is no navaid that can be used to track along
X      * that leg, set the .valid falg to FALSE.
X      */
X{
X   int this, to;
X   DATABASE_INFO *db;
X
X   /*
X    * invalidate all the current NAV1 settings
X    */
X   for (this = 0; this < num_waypoints; this++)
X      waypoints[this].vor_fix[0].valid = FALSE;
X
X   to = 0;
X   for (this = 0; (to != -1) && (this < num_waypoints); this++) {
X      to = next_non_incremental (this+1);
X      if (
X      /*
X       * if the next non-incremental waypoint is a navaid (or if an
X       * airport and there's a navaid colocated on the field) then use that
X       * as NAV1 for this waypoint and those up to that one
X       */
X      ((to >= 0) &&
X       (db = get_navaid (waypoints[to]))) ||
X      /*
X      * else, if this waypoint is a navaid, use it
X      */
X       (db = get_navaid (waypoints[this])) ) {
X     for (; this < to; this++) {
X        waypoints[this].vor_fix[0].valid = TRUE;
X        waypoints[this].vor_fix[0].db    = db;
X     }
X     this = to - 1;
X      }
X      /*
X       * else, we're out of luck - leave the fix invalid.
X       */
X   }
X}
X
X/*----------------------------------------------------------------------------*/
Xnormalize_heading (head)
X     double *head;
X{
X   if (*head < 0.0)
X      *head += 360.0;
X   else if (*head > 360.0)
X      *head -= 360.0;
X}
X
X/*----------------------------------------------------------------------------*/
Xstatic BOOLEAN do_fix (plane_heading, latitude, longitude, vor_fix, force_from)
X     double plane_heading;
X     double latitude;
X     double longitude;
X     VOR_FIX *vor_fix;
X     BOOLEAN force_from;
X{
X   double d;
X   double lat_from  = latitude;
X   double long_from = longitude;
X   double lat_to    = vor_fix->db->latitude;
X   double long_to   = vor_fix->db->longitude;
X
X   if (! vor_fix->db)
X      return FALSE;
X
X   if ((lat_from == lat_to) && (long_from == long_to))
X      return FALSE;
X
X   distance_and_heading (lat_from, long_from, lat_to, long_to,
X             &vor_fix->distance, &vor_fix->heading);
X   vor_fix->heading += vor_fix->db->mag_variation;
X   d = plane_heading - vor_fix->heading;
X   vor_fix->from_to = TO;
X   if (force_from || (d > 180.0) || (d < -180.0)) {
X      vor_fix->from_to = FROM;
X      vor_fix->heading += 180.0;
X   }
X   normalize_heading (&vor_fix->heading);
X   return TRUE;
X}
X
X/*----------------------------------------------------------------------------*/
XBOOLEAN compute_plan (auto_nav1)
X     BOOLEAN auto_nav1;
X{
X   int i;
X   int num_pairs = 0;
X#define MAX_NUM_PAIRS 30
X   double total_dist [MAX_NUM_PAIRS];
X   double distance, heading;
X
X   /*
X    * locate the waypoints specified only by distance from last waypoint:
X    */
X   locate_incrementals ();
X
X   /*
X    * accumulate the total distance between each from/to pair
X    */
X   num_pairs = 0;
X   for (i = 0; i < num_waypoints; i++) {
X      if (waypoints[i].wp_kind == WP_FROM) {
X     waypoints[i].eta.valid = TRUE;
X     waypoints[i].eta.value = 0.0;
X     total_dist [num_pairs] = 0.0;
X      }
X      if ((i+1 < num_waypoints) && (waypoints[i].wp_kind != WP_TO)) {
X     distance_and_heading (waypoints[i].db->latitude,
X                   waypoints[i].db->longitude,
X                   waypoints[i+1].db->latitude,
X                   waypoints[i+1].db->longitude,
X                   &distance, &heading);
X     waypoints[i].dist_leg.valid = TRUE;
X     waypoints[i].tc.valid       = TRUE;
X     waypoints[i].mc.valid       = TRUE;
X     waypoints[i].dist_leg.value = distance;
X     waypoints[i].tc.value       = heading;
X     waypoints[i].mc.value       = heading + waypoints[i].db->mag_variation;
X     normalize_heading (&waypoints[i].mc.value);
X     normalize_heading (&waypoints[i].tc.value);
X      } else {
X     waypoints[i].dist_leg.valid = FALSE;
X     waypoints[i].tc.valid       = FALSE;
X     waypoints[i].mc.valid       = FALSE;
X      }
X
X      waypoints[i].dist.valid = TRUE;
X      waypoints[i].dist.value = total_dist [num_pairs];
X
X      total_dist [num_pairs] += waypoints[i].dist_leg.value;
X
X      if (waypoints[i].wp_kind == WP_TO)
X     num_pairs++;
X   }
X
X   /*
X    * now, do the distance remaining:
X    */
X   num_pairs = 0.0;
X   for (i = 0; i < num_waypoints; i++) {
X      waypoints[i].dist_remain.value =
X     total_dist [num_pairs] - waypoints[i].dist.value;
X      waypoints[i].dist_remain.valid = TRUE;
X      if (waypoints[i].wp_kind == WP_TO)
X     num_pairs++;
X   }
X
X   /*
X    * wind correction (heading, ground speed)
X    */
X   for (i = 0; i < num_waypoints; i++) {
X      if (waypoints[i].tas.valid &&
X      waypoints[i].mc.valid) {
X
X     if (!waypoints[i].wind_speed.valid)
X        waypoints[i].wind_speed.value = 0.0;
X     if (!waypoints[i].wind_direction.valid)
X        waypoints[i].wind_direction.value = 0.0;
X
X     wind_correct (waypoints[i].tas.value,
X               waypoints[i].mc.value,
X               waypoints[i].wind_speed.value,
X               waypoints[i].wind_direction.value,
X               &waypoints[i].egs.value,
X               &waypoints[i].mh.value);
X
X     waypoints[i].egs.valid  = TRUE;
X     waypoints[i].mh.valid   = TRUE;
X     normalize_heading (&waypoints[i].mh.value);
X
X     /*
X      * time in hours
X      */
X     waypoints[i].eta_leg.valid = waypoints[i].dist_leg.valid;
X     waypoints[i].eta_leg.value = waypoints[i].dist_leg.value /
X        waypoints[i].egs.value;
X      } else {
X     waypoints[i].egs.valid     = FALSE;
X     waypoints[i].mh.valid      = FALSE;
X     waypoints[i].eta.valid     = FALSE;
X     waypoints[i].eta_leg.valid = FALSE;
X      }
X      waypoints[i].eta.valid     = (BOOLEAN) (waypoints[i].wp_kind != WP_FROM);
X      waypoints[i].eta.value     = (waypoints[i].dist.value == 0.0) ? 0.0 :
X     waypoints[i-1].eta_leg.value + waypoints[i-1].eta.value;
X   }
X
X   /*
X    * fuel burn:
X    */
X   for (i = 0; i < num_waypoints; i++) {
X      waypoints[i].fuel_leg.valid = (BOOLEAN) (waypoints[i].fuel_rate.valid &&
X                           waypoints[i].eta_leg.valid);
X      if (waypoints[i].fuel_leg.valid)
X     waypoints[i].fuel_leg.value =
X        waypoints[i].fuel_rate.value * waypoints[i].eta_leg.value;
X      if (waypoints[i].refuel) {
X     waypoints[i].fuel_amt.valid = TRUE;
X      } else if (i && (waypoints[i].wp_kind == WP_FROM) &&
X         (!waypoints[i].refuel)) {
X     waypoints[i].fuel_amt.valid = waypoints[i-1].fuel_amt.valid;
X     waypoints[i].fuel_amt.value = waypoints[i-1].fuel_amt.value;
X      } else if (i && waypoints[i-1].fuel_leg.valid &&
X         waypoints[i-1].fuel_amt.valid) {
X     waypoints[i].fuel_amt.value =
X        waypoints[i-1].fuel_amt.value - waypoints[i-1].fuel_leg.value;
X      }
X      if (waypoints[i].extra_fuel_burn.valid)
X     waypoints[i].fuel_amt.value -= waypoints[i].extra_fuel_burn.value;
X   }
X
X   if (auto_nav1)
X      track_nav1 ();
X
X   /*
X    * VOR cross fixes:
X    */
X   {
X      int vor;
X      for (i = 0; i < num_waypoints; i++) {
X     for (vor = 0; vor < MAX_NUM_VOR_FIXES; vor++) {
X        if (waypoints[i].vor_fix[vor].valid) {
X           if (! do_fix (waypoints[i].mh.value, waypoints[i].db->latitude,
X                 waypoints[i].db->longitude,
X                 &waypoints[i].vor_fix[vor], FALSE) ) {
X          /*
X           * if we failed to compute an xfix, it could be because we're
X           * right on top of the navaid - pretend we're at the next
X           * waypoint (since that's where we're going...)
X           */
X          if ((i+1) < num_waypoints) {
X             if (!do_fix (waypoints[i].mh.value,
X                  waypoints[i+1].db->latitude,
X                  waypoints[i+1].db->longitude,
X                  &waypoints[i].vor_fix[vor], TRUE))
X            waypoints[i].vor_fix[vor].valid = FALSE;
X          } else
X             waypoints[i].vor_fix[vor].valid = FALSE;
X           }
X        }
X     }
X      }
X   }
X   return TRUE;
X}
X
X
SHAR_EOF
chmod 0444 compute.c || echo "restore of compute.c fails"
exit 0